CS5302 – OPERATING SYSTEMS LABORATORY

/* C Concept Representation: Single-Instance (Cycle Finding) vs Multi-Instance */
#include <stdio.h>
#include <stdbool.h>

#define MAX_PROC 10
#define MAX_RES 10

// Multi-Instance Detection Engine
bool detectMultiInstanceDeadlock(int n, int m, int alloc[MAX_PROC][MAX_RES], 
                                 int req[MAX_PROC][MAX_RES], int avail[MAX_RES], int deadlocked[]) {
    int work[MAX_RES];
    bool finish[MAX_PROC];
    int deadCount = 0;

    for (int j = 0; j < m; j++) work[j] = avail[j];
    for (int i = 0; i < n; i++) {
        bool hasAlloc = false;
        for (int j = 0; j < m; j++) if (alloc[i][j] != 0) { hasAlloc = true; break; }
        finish[i] = !hasAlloc;
    }

    bool progress;
    do {
        progress = false;
        for (int i = 0; i < n; i++) {
            if (!finish[i]) {
                bool canSatisfy = true;
                for (int j = 0; j < m; j++) {
                    if (req[i][j] > work[j]) { canSatisfy = false; break; }
                }
                if (canSatisfy) {
                    for (int j = 0; j < m; j++) work[j] += alloc[i][j];
                    finish[i] = true;
                    progress = true;
                }
            }
        }
    } while (progress);

    for (int i = 0; i < n; i++) {
        if (!finish[i]) deadlocked[deadCount++] = i;
    }
    return deadCount > 0;
}

#include <stdio.h>

#define FRAMES 4
#define REF_LEN 12

int main() {
    int ref_str[REF_LEN] = {1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5};
    int frames[FRAMES];
    int victim = 0;
    int page_faults = 0, page_hits = 0;

    for (int i = 0; i < FRAMES; i++) frames[i] = -1;

    printf("FIFO Page Replacement Simulation (Frames = %d)\n", FRAMES);
    printf("Reference String: 1 2 3 4 1 2 5 1 2 3 4 5\n\n");
    printf("%-5s | %-16s | %-10s\n", "Page", "Frame State", "Status");
    printf("-----------------------------------------\n");

    for (int i = 0; i < REF_LEN; i++) {
        int page = ref_str[i];
        int hit = 0;

        for (int j = 0; j < FRAMES; j++) {
            if (frames[j] == page) {
                hit = 1;
                page_hits++;
                break;
            }
        }

        if (!hit) {
            frames[victim] = page;
            victim = (victim + 1) % FRAMES;
            page_faults++;
            printf("%-5d | [", page);
            for (int j = 0; j < FRAMES; j++) {
                if (frames[j] != -1) printf(" %d", frames[j]);
                else printf(" -");
            }
            printf(" ] | FAULT (F%d)\n", victim == 0 ? FRAMES : victim);
        } else {
            printf("%-5d | [", page);
            for (int j = 0; j < FRAMES; j++) {
                if (frames[j] != -1) printf(" %d", frames[j]);
                else printf(" -");
            }
            printf(" ] | HIT\n");
        }
    }

    printf("-----------------------------------------\n");
    printf("Total References : %d\n", REF_LEN);
    printf("Total Page Faults: %d\n", page_faults);
    printf("Total Page Hits  : %d\n", page_hits);
    printf("Hit Ratio        : %.2f%%\n", ((float)page_hits / REF_LEN) * 100);
    printf("Fault Ratio      : %.2f%%\n", ((float)page_faults / REF_LEN) * 100);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

#define PAGE_SIZE 1024       // 1 KB
#define TOTAL_PAGES 4        // Legal pages: 0, 1, 2, 3

int page_table[TOTAL_PAGES] = {5, 8, 2, 9}; // Frame mapping

void translateAddress(unsigned int logical_addr) {
    unsigned int page_no = logical_addr / PAGE_SIZE;
    unsigned int offset = logical_addr % PAGE_SIZE;

    printf("\n[Translating Logical Address: %u]\n", logical_addr);
    printf("Calculated Page Number: %u | Offset: %u\n", page_no, offset);

    // Hardware MMU Bound Check
    if (page_no >= TOTAL_PAGES) {
        printf(">>> [HARDWARE TRAP]: Page %u exceeds Page Table Limit (%d)!\n", page_no, TOTAL_PAGES);
        printf(">>> TRAP TYPE   : Addressing Exception / Segmentation Fault\n");
        printf(">>> OS ACTION   : Signal SIGSEGV sent. Process Aborted.\n");
    } else {
        unsigned int physical_addr = (page_table[page_no] * PAGE_SIZE) + offset;
        printf(">>> Status: VALID (Mapped to Frame %d)\n", page_table[page_no]);
        printf(">>> Physical Address = (%d * %d) + %u = %u\n", 
               page_table[page_no], PAGE_SIZE, offset, physical_addr);
    }
}

int main() {
    printf("=== Paging Bounds Checking Demonstration ===\n");
    printf("Page Size = %d bytes | Valid Pages = 0 to %d\n", PAGE_SIZE, TOTAL_PAGES - 1);

    translateAddress(2500);  // Page 2, Offset 452 -> VALID
    translateAddress(4095);  // Page 3, Offset 1023 -> VALID
    translateAddress(6500);  // Page 6 -> EXCEEDS TOTAL PAGES!

    return 0;
}

/* Directory-Related Commands:
1. pwd (Print Working Directory)
   Syntax: pwd [-L | -P]
   Example: $ pwd
            /home/student/oslab

2. mkdir (Make Directory)
   Syntax: mkdir [options] <dirname>
   Example: $ mkdir -p lab/ex4/code

3. cd (Change Directory)
   Syntax: cd [directory_path]
   Example: $ cd lab/ex4 && pwd

4. rmdir (Remove Empty Directory)
   Syntax: rmdir [options] <dirname>
   Example: $ rmdir temp_dir

5. ls (List Directory Contents)
   Syntax: ls [options] [path]
   Example: $ ls -la /var/log

File-Related Commands:
1. touch (Create Empty File / Update Timestamp)
   Syntax: touch <filename>
   Example: $ touch sample.txt

2. cat (Concatenate and Display Files)
   Syntax: cat [options] [files]
   Example: $ cat -n sample.txt

3. cp (Copy Files and Directories)
   Syntax: cp [options] <source> <destination>
   Example: $ cp -r src_folder/ dest_folder/

4. mv (Move or Rename Files)
   Syntax: mv [options] <source> <destination>
   Example: $ mv oldname.c newname.c

5. rm (Remove / Delete Files)
   Syntax: rm [options] <filename>
   Example: $ rm -f obsolete.log
*/

/* Effective Access Time (EAT) Calculation Model */
// EAT = (1 - p) * Memory_Access_Time + p * Page_Fault_Service_Time
// If Memory Access = 100 ns, Page Fault Service = 10 ms (10,000,000 ns)
// If p = 0.001 (1 fault in 1000 references):
// EAT = 0.999 * 100 + 0.001 * 10,000,000 = 99.9 + 10,000 = 10,099.9 ns ≈ 10 microseconds!
// (100 times slower due to disk swap latency)

/* Common cat command applications:
1. Create new file with standard input:
   $ cat > notes.txt
   Line 1
   Line 2
   (Ctrl+D)

2. Display file with line numbers:
   $ cat -n notes.txt

3. Concatenate two files into a destination file:
   $ cat part1.txt part2.txt > full_report.txt

4. Append file content:
   $ cat appendix.txt >> full_report.txt

5. Suppress duplicate blank lines:
   $ cat -s report.txt
*/

/* Practical Examples: */
// View first 3 lines of system users
$ head -n 3 /etc/passwd

// Monitor real-time authentication logs
$ tail -f /var/log/auth.log

// Search case-insensitively with line numbers
$ grep -in "error" /var/log/syslog

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    pid_t pid;

    printf("Parent Process before fork() [PID: %d]\n\n", getpid());
    pid = fork();

    if (pid < 0) {
        perror("Fork failed");
        return 1;
    } else if (pid == 0) {
        // Child execution path
        printf("[CHILD PROCESS]\n");
        printf("  My PID           : %d\n", getpid());
        printf("  My Parent's PPID : %d\n", getppid());
    } else {
        // Parent execution path
        wait(NULL); // Wait for child completion
        printf("\n[PARENT PROCESS]\n");
        printf("  My PID           : %d\n", getpid());
        printf("  Created Child PID: %d\n", pid);
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        perror("Fork failed");
        exit(1);
    } else if (pid == 0) {
        printf("Child (PID: %d) executing work...\n", getpid());
        sleep(2); // Simulate task
        printf("Child task finished. Exiting with code 42.\n");
        exit(42);
    } else {
        int status;
        printf("Parent (PID: %d) waiting for Child (PID: %d)...\n", getpid(), pid);
        pid_t dead_child = wait(&status);

        if (WIFEXITED(status)) {
            printf("Parent: Child %d terminated normally with exit code %d.\n", 
                   dead_child, WEXITSTATUS(status));
        }
        printf("Parent resuming and terminating.\n");
    }
    return 0;
}

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
    int fd;
    char buffer[64];
    ssize_t bytes_written, bytes_read;

    // Open file for read/write, create if not present
    fd = open("exam_test.txt", O_CREAT | O_RDWR | O_TRUNC, 0644);
    if (fd < 0) {
        perror("Failed to open file");
        exit(1);
    }
    printf("File opened successfully with File Descriptor: %d\n", fd);

    // Write content
    bytes_written = write(fd, "OS Lab Exam 2026\n", 17);
    printf("Written %zd bytes to file.\n", bytes_written);

    // Reposition cursor to beginning
    lseek(fd, 0, SEEK_SET);

    // Read back
    bytes_read = read(fd, buffer, sizeof(buffer) - 1);
    buffer[bytes_read] = '\0';
    printf("Read from file: %s", buffer);

    // Close file descriptor
    if (close(fd) == 0) {
        printf("File descriptor %d closed successfully.\n", fd);
    } else {
        perror("Close failed");
    }

    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
    int shared_var = 100;
    pid_t pid = fork();

    if (pid < 0) {
        fprintf(stderr, "Fork failed!\n");
        return 1;
    } else if (pid == 0) {
        shared_var += 50;
        printf("[CHILD PROCESS] PID: %d, PPID: %d | Local shared_var = %d\n", 
               getpid(), getppid(), shared_var);
    } else {
        printf("[PARENT PROCESS] PID: %d, Child PID: %d | Local shared_var = %d\n", 
               getpid(), pid, shared_var);
    }
    return 0;
}

#include <stdio.h>

int main() {
    int n = 4;
    int bt[] = {5, 3, 8, 6};
    int wt[4], tat[4];
    float total_wt = 0, total_tat = 0;

    wt[0] = 0; // First process waits 0 ms
    tat[0] = bt[0];

    for (int i = 1; i < n; i++) {
        wt[i] = wt[i - 1] + bt[i - 1];
        tat[i] = wt[i] + bt[i];
    }

    printf("=== FCFS CPU SCHEDULING (C Program) ===\n");
    printf("%-8s | %-10s | %-12s | %-15s\n", "Process", "Burst Time", "Waiting Time", "Turnaround Time");
    printf("---------------------------------------------------\n");

    for (int i = 0; i < n; i++) {
        total_wt += wt[i];
        total_tat += tat[i];
        printf("P%-7d | %-10d | %-12d | %-15d\n", i + 1, bt[i], wt[i], tat[i]);
    }

    printf("---------------------------------------------------\n");
    printf("Average Waiting Time    : %.2f ms\n", total_wt / n);
    printf("Average Turnaround Time : %.2f ms\n", total_tat / n);

    return 0;
}

#include <stdio.h>

int main() {
    int n = 4;
    int p[] = {1, 2, 3, 4};
    int bt[] = {6, 8, 3, 4};
    int wt[4], tat[4];
    float total_wt = 0, total_tat = 0;

    // Sort by Burst Time (Bubble Sort)
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (bt[j] > bt[j + 1]) {
                int temp = bt[j]; bt[j] = bt[j + 1]; bt[j + 1] = temp;
                temp = p[j]; p[j] = p[j + 1]; p[j + 1] = temp;
            }
        }
    }

    wt[0] = 0;
    tat[0] = bt[0];
    for (int i = 1; i < n; i++) {
        wt[i] = wt[i - 1] + bt[i - 1];
        tat[i] = wt[i] + bt[i];
    }

    printf("=== SJF NON-PREEMPTIVE CPU SCHEDULING ===\n");
    printf("%-8s | %-10s | %-12s | %-15s\n", "Process", "Burst Time", "Waiting Time", "Turnaround Time");
    printf("---------------------------------------------------\n");

    for (int i = 0; i < n; i++) {
        total_wt += wt[i]; total_tat += tat[i];
        printf("P%-7d | %-10d | %-12d | %-15d\n", p[i], bt[i], wt[i], tat[i]);
    }
    printf("---------------------------------------------------\n");
    printf("Average Waiting Time    : %.2f ms\n", total_wt / n);
    printf("Average Turnaround Time : %.2f ms\n", total_tat / n);

    return 0;
}

#include <stdio.h>

int main() {
    int n = 4;
    int p[] = {1, 2, 3, 4};
    int bt[] = {10, 1, 2, 1};
    int pr[] = {3, 1, 4, 2}; // 1 = Highest Priority
    int wt[4], tat[4];
    float total_wt = 0, total_tat = 0;

    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (pr[j] > pr[j + 1]) {
                int t = pr[j]; pr[j] = pr[j + 1]; pr[j + 1] = t;
                t = bt[j]; bt[j] = bt[j + 1]; bt[j + 1] = t;
                t = p[j]; p[j] = p[j + 1]; p[j + 1] = t;
            }
        }
    }

    wt[0] = 0;
    tat[0] = bt[0];
    for (int i = 1; i < n; i++) {
        wt[i] = wt[i - 1] + bt[i - 1];
        tat[i] = wt[i] + bt[i];
    }

    printf("=== PRIORITY CPU SCHEDULING (C Program) ===\n");
    printf("%-8s | %-8s | %-10s | %-12s | %-15s\n", "Process", "Priority", "Burst Time", "Waiting Time", "Turnaround Time");
    printf("--------------------------------------------------------------\n");

    for (int i = 0; i < n; i++) {
        total_wt += wt[i]; total_tat += tat[i];
        printf("P%-7d | %-8d | %-10d | %-12d | %-15d\n", p[i], pr[i], bt[i], wt[i], tat[i]);
    }
    printf("--------------------------------------------------------------\n");
    printf("Average Waiting Time    : %.2f ms\n", total_wt / n);
    printf("Average Turnaround Time : %.2f ms\n", total_tat / n);

    return 0;
}

#include <stdio.h>

int main() {
    int n = 3, quantum = 2;
    int bt[] = {5, 4, 3};
    int rem_bt[] = {5, 4, 3};
    int wt[3] = {0}, tat[3] = {0};
    int t = 0; // Current time

    while (1) {
        int done = 1;
        for (int i = 0; i < n; i++) {
            if (rem_bt[i] > 0) {
                done = 0;
                if (rem_bt[i] > quantum) {
                    t += quantum;
                    rem_bt[i] -= quantum;
                } else {
                    t += rem_bt[i];
                    wt[i] = t - bt[i];
                    rem_bt[i] = 0;
                }
            }
        }
        if (done == 1) break;
    }

    float total_wt = 0, total_tat = 0;
    for (int i = 0; i < n; i++) {
        tat[i] = bt[i] + wt[i];
        total_wt += wt[i];
        total_tat += tat[i];
    }

    printf("=== ROUND ROBIN SCHEDULING (Quantum = %d) ===\n", quantum);
    printf("%-8s | %-10s | %-12s | %-15s\n", "Process", "Burst Time", "Waiting Time", "Turnaround Time");
    printf("---------------------------------------------------\n");
    for (int i = 0; i < n; i++) {
        printf("P%-7d | %-10d | %-12d | %-15d\n", i + 1, bt[i], wt[i], tat[i]);
    }
    printf("---------------------------------------------------\n");
    printf("Average Waiting Time    : %.2f ms\n", total_wt / n);
    printf("Average Turnaround Time : %.2f ms\n", total_tat / n);

    return 0;
}

Gantt Chart Representation:
+-------+-------+---------------+-----------+
|  P1   |  P2   |      P3       |    P4     |
+-------+-------+---------------+-----------+
0       5       8              16          22

Calculations:
Total Waiting Time (TWT) = 0 + 5 + 8 + 16 = 29 ms
Average Waiting Time (AWT) = TWT / 4 = 29 / 4 = 7.25 ms

Total Turnaround Time (TTAT) = 5 + 8 + 16 + 22 = 51 ms
Average Turnaround Time (ATAT) = TTAT / 4 = 51 / 4 = 12.75 ms

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

int main() {
    int fd[2];
    pid_t pid;
    char write_msg[] = "Hello from Child Process via Pipe!";
    char read_msg[100];

    if (pipe(fd) == -1) {
        perror("Pipe creation failed");
        return 1;
    }

    pid = fork();
    if (pid < 0) {
        perror("Fork failed");
        return 1;
    } else if (pid == 0) {
        // Child Process -> Writer
        close(fd[0]); // Close unused read end
        printf("[CHILD] Writing message to pipe...\n");
        write(fd[1], write_msg, strlen(write_msg) + 1);
        close(fd[1]); // Close write end after sending
    } else {
        // Parent Process -> Reader
        close(fd[1]); // Close unused write end
        wait(NULL);   // Wait for child to write
        read(fd[0], read_msg, sizeof(read_msg));
        printf("[PARENT] Successfully received message from pipe: '%s'\n", read_msg);
        close(fd[0]); // Close read end
    }

    return 0;
}

Summary Statistics:
Total Memory References: 13
Total Page Faults (Misses): 10 Page Faults
Total Page Hits           : 3 Page Hits
Hit Ratio                 : (3 / 13) * 100 = 23.08%
Fault Ratio               : (10 / 13) * 100 = 76.92%

Final Allocation Status:
Process P1 (357 KB) -> Allocated to Block 1 (500 KB) | Remaining = 143 KB
Process P2 (129 KB) -> Allocated to Block 2 (200 KB) | Remaining = 71 KB
Process P3 (191 KB) -> Allocated to Block 3 (300 KB) | Remaining = 109 KB

Unallocated Free Block:
Block 4 (600 KB) -> Completely Unused / Free!
Total Memory Allocated = 357 + 129 + 191 = 677 KB
Total Internal Fragmentation = 143 + 71 + 109 = 323 KB

#include <stdio.h>

void calculatePaging(unsigned int logical_addr, unsigned int page_size) {
    unsigned int page_number = logical_addr / page_size;
    unsigned int offset = logical_addr % page_size;

    printf("Logical Address : %u bytes\n", logical_addr);
    printf("Page Size       : %u bytes\n", page_size);
    printf("-----------------------------------------\n");
    printf("Derived Page No : %u\n", page_number);
    printf("Derived Offset  : %u bytes\n", offset);
    printf("Verification    : (%u * %u) + %u = %u\n\n", 
           page_number, page_size, offset, (page_number * page_size) + offset);
}

int main() {
    printf("=== LOGICAL ADDRESS TRANSLATOR (C) ===\n");
    calculatePaging(7250, 1024); // 1 KB page size
    calculatePaging(18500, 4096); // 4 KB page size
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    int pfd[2];
    pid_t pid;
    char write_buf[] = "System Call Communication: Kernel Pipe Active";
    char read_buf[100];

    if (pipe(pfd) == -1) {
        perror("pipe creation failed");
        return 1;
    }

    pid = fork();
    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // Child acts as reader
        close(pfd[1]); // Close unused write descriptor
        read(pfd[0], read_buf, sizeof(read_buf));
        printf("[CHILD READER] Received message: "%s"\n", read_buf);
        close(pfd[0]);
    } else {
        // Parent acts as writer
        close(pfd[0]); // Close unused read descriptor
        printf("[PARENT WRITER] Transmitting buffer through pipefd[1]...\n");
        write(pfd[1], write_buf, strlen(write_buf) + 1);
        close(pfd[1]);
        wait(NULL); // Synchronize with child
    }

    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>

int main() {
    int fd[2];
    pid_t pid;
    char child_msg[] = "STATUS_OK: Child task executed successfully.";
    char buffer[128];

    if (pipe(fd) < 0) { perror("Pipe failed"); exit(1); }
    pid = fork();

    if (pid < 0) { perror("Fork failed"); exit(1); }

    if (pid == 0) {
        // Child Process -> Producer
        close(fd[0]); // Close read end
        printf("[CHILD (PID: %d)] Sending telemetry to parent...\n", getpid());
        write(fd[1], child_msg, strlen(child_msg) + 1);
        close(fd[1]);
        exit(0);
    } else {
        // Parent Process -> Consumer
        close(fd[1]); // Close write end
        wait(NULL);   // Wait for child
        read(fd[0], buffer, sizeof(buffer));
        printf("[PARENT (PID: %d)] Received packet from child: '%s'\n", getpid(), buffer);
        close(fd[0]);
    }

    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

sem_t mutex;
int shared_counter = 0;

void* process_worker(void* arg) {
    long id = (long)arg;
    
    // Entry Section
    sem_wait(&mutex);
    
    // Critical Section
    printf("[PROCESS/THREAD %ld] Entered Critical Section. Counter = %d\n", id, shared_counter);
    int temp = shared_counter;
    sleep(1); // Simulate time spent in Critical Section
    shared_counter = temp + 1;
    printf("[PROCESS/THREAD %ld] Exiting Critical Section. New Counter = %d\n", id, shared_counter);
    
    // Exit Section
    sem_post(&mutex);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    sem_init(&mutex, 0, 1); // Binary semaphore initialized to 1

    pthread_create(&t1, NULL, process_worker, (void*)1);
    pthread_create(&t2, NULL, process_worker, (void*)2);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    sem_destroy(&mutex);
    printf("Final Shared Counter: %d (Expected: 2)\n", shared_counter);
    return 0;
}

/* Usage Template */
sem_t s;
sem_init(&s, 0, 1); // Mutex

sem_wait(&s);
// Critical Section code here
sem_post(&s);

sem_destroy(&s);

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

sem_t cs_sem;

void* worker(void* arg) {
    int id = *((int*)arg);
    printf("Thread %d: Requesting entry into Critical Section...\n", id);

    sem_wait(&cs_sem); // P operation
    printf(">>> Thread %d: GRANTED entry. Inside Critical Section.\n", id);
    sleep(2); // In CS
    printf("<<< Thread %d: LEAVING Critical Section.\n", id);
    sem_post(&cs_sem); // V operation

    return NULL;
}

int main() {
    pthread_t t1, t2;
    int id1 = 1, id2 = 2;

    sem_init(&cs_sem, 0, 1);

    pthread_create(&t1, NULL, worker, &id1);
    pthread_create(&t2, NULL, worker, &id2);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    sem_destroy(&cs_sem);
    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

#define ITERATIONS 100000
int counter = 0;
sem_t lock;

void* thread_func(void* arg) {
    for (int i = 0; i < ITERATIONS; i++) {
        sem_wait(&lock); // Mutual exclusion lock
        counter++;       // Atomic Critical Section
        sem_post(&lock);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    sem_init(&lock, 0, 1);

    pthread_create(&t1, NULL, thread_func, NULL);
    pthread_create(&t2, NULL, thread_func, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("Counter with Semaphore Protection = %d (Expected: %d)\n", 
           counter, 2 * ITERATIONS);

    sem_destroy(&lock);
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <semaphore.h>
#include <fcntl.h>
#include <sys/wait.h>

#define SEM_NAME "/os_sync_sem"

int main() {
    sem_t *sem = sem_open(SEM_NAME, O_CREAT | O_EXCL, 0644, 0); // Init 0
    if (sem == SEM_FAILED) {
        sem_unlink(SEM_NAME);
        sem = sem_open(SEM_NAME, O_CREAT, 0644, 0);
    }

    pid_t pid = fork();

    if (pid == 0) {
        // Child
        printf("[CHILD] Executing primary initialization step...\n");
        sleep(2);
        printf("[CHILD] Step complete. Signaling parent via sem_post()...\n");
        sem_post(sem);
    } else {
        // Parent
        printf("[PARENT] Waiting for child signal via sem_wait()...\n");
        sem_wait(sem); // Blocks until child posts
        printf("[PARENT] Received signal! Proceeding to next phase.\n");
        wait(NULL);
        sem_close(sem);
        sem_unlink(SEM_NAME);
    }

    return 0;
}

#include <stdio.h>
#include <stdbool.h>

#define P 5 // Processes
#define R 3 // Resources

int main() {
    int alloc[P][R] = { {0, 1, 0}, {2, 0, 0}, {3, 0, 2}, {2, 1, 1}, {0, 0, 2} };
    int max[P][R]   = { {7, 5, 3}, {3, 2, 2}, {9, 0, 2}, {2, 2, 2}, {4, 3, 3} };
    int avail[R]    = {3, 3, 2};

    int need[P][R];
    for (int i = 0; i < P; i++)
        for (int j = 0; j < R; j++)
            need[i][j] = max[i][j] - alloc[i][j];

    bool finish[P] = {0};
    int safeSeq[P];
    int work[R];
    for (int i = 0; i < R; i++) work[i] = avail[i];

    int count = 0;
    while (count < P) {
        bool found = false;
        for (int p = 0; p < P; p++) {
            if (!finish[p]) {
                int j;
                for (j = 0; j < R; j++)
                    if (need[p][j] > work[j]) break;

                if (j == R) {
                    for (int k = 0; k < R; k++) work[k] += alloc[p][k];
                    safeSeq[count++] = p;
                    finish[p] = true;
                    found = true;
                }
            }
        }
        if (!found) {
            printf("System is NOT in a safe state (Deadlock imminent)!\n");
            return 1;
        }
    }

    printf("=== BANKER'S ALGORITHM RESULT ===\n");
    printf("The System is in a SAFE STATE.\nSafe Sequence is: < ");
    for (int i = 0; i < P; i++) printf("P%d ", safeSeq[i]);
    printf(">\n");

    return 0;
}

#include <stdio.h>

int main() {
    int n = 5, m = 3;
    int alloc[5][3] = {{0, 1, 0}, {2, 0, 0}, {3, 0, 2}, {2, 1, 1}, {0, 0, 2}};
    int max[5][3]   = {{7, 5, 3}, {3, 2, 2}, {9, 0, 2}, {2, 2, 2}, {4, 3, 3}};
    int need[5][3];

    printf("=== NEED MATRIX COMPUTATION (Need = Max - Allocation) ===\n");
    printf("Process | Max (A B C) | Alloc (A B C) | Need (A B C)\n");
    printf("------------------------------------------------------\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            need[i][j] = max[i][j] - alloc[i][j];
        }
        printf("P%-6d | %d %d %d       | %d %d %d         | %d %d %d\n",
               i, max[i][0], max[i][1], max[i][2],
               alloc[i][0], alloc[i][1], alloc[i][2],
               need[i][0], need[i][1], need[i][2]);
    }
    return 0;
}

#include <stdio.h>
#include <stdbool.h>

int main() {
    int n = 5, m = 3;
    int alloc[5][3] = { {0, 1, 0}, {2, 0, 0}, {3, 0, 3}, {2, 1, 1}, {0, 0, 2} };
    int req[5][3]   = { {0, 0, 0}, {2, 0, 2}, {0, 0, 0}, {1, 0, 0}, {0, 0, 2} };
    int avail[3]    = {0, 0, 0};

    int work[3];
    bool finish[5];

    for (int j = 0; j < m; j++) work[j] = avail[j];

    for (int i = 0; i < n; i++) {
        bool hasAlloc = false;
        for (int j = 0; j < m; j++) if (alloc[i][j] != 0) { hasAlloc = true; break; }
        finish[i] = !hasAlloc;
    }

    bool progress;
    do {
        progress = false;
        for (int i = 0; i < n; i++) {
            if (!finish[i]) {
                bool canProceed = true;
                for (int j = 0; j < m; j++) {
                    if (req[i][j] > work[j]) { canProceed = false; break; }
                }
                if (canProceed) {
                    for (int j = 0; j < m; j++) work[j] += alloc[i][j];
                    finish[i] = true;
                    progress = true;
                }
            }
        }
    } while (progress);

    int deadlocked = 0;
    printf("=== DEADLOCK DETECTION REPORT ===\n");
    for (int i = 0; i < n; i++) {
        if (!finish[i]) {
            printf(">>> Process P%d is DEADLOCKED.\n", i);
            deadlocked++;
        }
    }

    if (deadlocked == 0) printf("No deadlock detected. All processes can finish.\n");
    else printf("Total Deadlocked Processes: %d\n", deadlocked);

    return 0;
}

#include <stdio.h>
#include <stdbool.h>

int main() {
    int n = 3, m = 2;
    int alloc[3][2] = {{1, 0}, {0, 1}, {1, 1}};
    int req[3][2]   = {{0, 1}, {1, 0}, {0, 0}};
    int avail[2]    = {0, 0};

    int work[2] = {0, 0};
    bool finish[3] = {false, false, false};

    // P2 has no requests (req is 0, 0)
    for (int i = 0; i < n; i++) {
        if (req[i][0] == 0 && req[i][1] == 0) {
            work[0] += alloc[i][0];
            work[1] += alloc[i][1];
            finish[i] = true;
        }
    }

    // Attempt resolving remaining
    for (int i = 0; i < n; i++) {
        if (!finish[i] && req[i][0] <= work[0] && req[i][1] <= work[1]) {
            work[0] += alloc[i][0];
            work[1] += alloc[i][1];
            finish[i] = true;
        }
    }

    printf("Deadlock Status:\n");
    for (int i = 0; i < n; i++) {
        printf("Process P%d: %s\n", i, finish[i] ? "Finished (OK)" : "DEADLOCKED");
    }
    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void* taskA(void* arg) {
    for (int i = 1; i <= 3; i++) {
        printf("[THREAD A] Executing iteration %d\n", i);
        sleep(1);
    }
    return NULL;
}

void* taskB(void* arg) {
    for (int i = 1; i <= 3; i++) {
        printf("   [THREAD B] Executing iteration %d\n", i);
        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    printf("=== POSIX THREAD CONCURRENCY (C) ===\n");
    pthread_create(&thread1, NULL, taskA, NULL);
    pthread_create(&thread2, NULL, taskB, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("Both threads joined successfully. Main exiting.\n");
    return 0;
}

/* Example Template */
pthread_t tid;
int arg_val = 10;
pthread_create(&tid, NULL, my_func, (void*)&arg_val);
void *result;
pthread_join(tid, &result);

/* Diagrammatic Representation:
Logical Address: [ Page Number (p) | Offset (d) ]
                         |
                   (Page Table)
                         ↓
Physical Address: [ Frame Number (f) | Offset (d) ]
*/

#include <stdio.h>

int main() {
    int bsize[] = {100, 500, 200, 300, 600};
    int psize[] = {212, 417, 112, 426};
    int m = 5, n = 4;
    int allocation[4];

    for (int i = 0; i < n; i++) allocation[i] = -1;

    for (int i = 0; i < n; i++) {
        int bestIdx = -1;
        for (int j = 0; j < m; j++) {
            if (bsize[j] >= psize[i]) {
                if (bestIdx == -1 || bsize[j] < bsize[bestIdx]) {
                    bestIdx = j;
                }
            }
        }
        if (bestIdx != -1) {
            allocation[i] = bestIdx;
            bsize[bestIdx] -= psize[i];
        }
    }

    printf("=== BEST FIT MEMORY ALLOCATION (C) ===\n");
    printf("Process No | Process Size | Block Allocated | Remaining Block\n");
    printf("------------------------------------------------------------\n");
    for (int i = 0; i < n; i++) {
        printf("P%-9d | %-12d | ", i + 1, psize[i]);
        if (allocation[i] != -1)
            printf("Block %-9d | %d KB\n", allocation[i] + 1, bsize[allocation[i]]);
        else
            printf("Not Allocated   | ---\n");
    }
    return 0;
}

/* Fragmentation Comparison Matrix:
Feature             | Internal Fragmentation          | External Fragmentation
--------------------+---------------------------------+---------------------------------
Location of Waste   | Inside allocated partition      | Outside allocated partitions
Cause               | Fixed block/page size allocation| Varying sized dynamic requests
Affected Algorithms | Paging, Fixed Partitioning      | Dynamic Partitioning, Segmentation
Remedy              | Smaller page/partition size    | Compaction, Paging (Non-contiguous)
*/

#include <stdio.h>

int findLRU(int time[], int n) {
    int min = time[0], pos = 0;
    for (int i = 1; i < n; i++) {
        if (time[i] < min) { min = time[i]; pos = i; }
    }
    return pos;
}

int main() {
    int frames[3] = {-1, -1, -1};
    int time[3] = {0};
    int ref[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3};
    int n = 10, total_frames = 3;
    int faults = 0, counter = 0;

    printf("=== LRU PAGE REPLACEMENT (C Program) ===\n");
    for (int i = 0; i < n; i++) {
        int page = ref[i];
        int hit = 0;
        counter++;

        for (int j = 0; j < total_frames; j++) {
            if (frames[j] == page) {
                hit = 1;
                time[j] = counter;
                break;
            }
        }

        if (!hit) {
            int pos = -1;
            for (int j = 0; j < total_frames; j++) {
                if (frames[j] == -1) { pos = j; break; }
            }
            if (pos == -1) pos = findLRU(time, total_frames);

            frames[pos] = page;
            time[pos] = counter;
            faults++;
            printf("Page %d -> [%d, %d, %d] : FAULT\n", page, frames[0], frames[1], frames[2]);
        } else {
            printf("Page %d -> [%d, %d, %d] : HIT\n", page, frames[0], frames[1], frames[2]);
        }
    }

    printf("Total Page Faults (LRU): %d\n", faults);
    return 0;
}